home *** CD-ROM | disk | FTP | other *** search
/ Programming a Multiplayer FPS in DirectX / Programming a Multiplayer FPS in DirectX (Companion CD).iso / DirectX / dxsdk_oct2004.exe / dxsdk.exe / Samples / C++ / Direct3D / EffectEdit / RenderView.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2004-09-27  |  58.0 KB  |  1,640 lines
  1. // RenderView.cpp : implementation of the CRenderView class
  2. //
  3.  
  4. #include "stdafx.h"
  5. #include "EffectEdit.h"
  6.  
  7. #include "EffectDoc.h"
  8. #include "UIElements.h"
  9. #include "RenderView.h"
  10.  
  11. #ifdef _DEBUG
  12. #define new DEBUG_NEW
  13. #undef THIS_FILE
  14. static char THIS_FILE[] = __FILE__;
  15. #endif
  16.  
  17. // Custom vertex type for the flat-texture background
  18. struct FLATBACKGROUNDVERTEX
  19. {
  20.     float x,y,z,w;
  21.     float u,v;
  22.  
  23.     static const DWORD FVF;
  24. };
  25. const DWORD FLATBACKGROUNDVERTEX::FVF = D3DFVF_XYZRHW | D3DFVF_TEX1;
  26.  
  27.  
  28. // Custom vertex type for the cubemap-texture background
  29. struct CUBEBACKGROUNDVERTEX
  30. { 
  31.     float x,y,z; 
  32.     float u,v,w; 
  33.  
  34.     static const DWORD FVF;
  35. };
  36. const DWORD CUBEBACKGROUNDVERTEX::FVF = D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_TEXCOORDSIZE3(0);
  37.  
  38. /////////////////////////////////////////////////////////////////////////////
  39. // CRenderView
  40.  
  41. static CRenderView* s_pRenderView = NULL;
  42.  
  43.  
  44. IMPLEMENT_DYNCREATE(CRenderView, CFormView)
  45.  
  46. BEGIN_MESSAGE_MAP(CRenderView, CFormView)
  47.     //{{AFX_MSG_MAP(CRenderView)
  48.     ON_WM_DESTROY()
  49.     ON_WM_SIZE()
  50.     ON_COMMAND(ID_VIEW_RENDER, OnRender)
  51.     //}}AFX_MSG_MAP
  52. END_MESSAGE_MAP()
  53.  
  54. /////////////////////////////////////////////////////////////////////////////
  55. // CRenderView construction/destruction
  56.  
  57. CRenderView::CRenderView()
  58.     : CFormView(CRenderView::IDD)
  59. {
  60.     //{{AFX_DATA_INIT(CRenderView)
  61.         // NOTE: the ClassWizard will add member initialization here
  62.     //}}AFX_DATA_INIT
  63.     // TODO: add construction code here
  64.     m_bShowStats = TRUE;
  65.     m_pFont = NULL;
  66.     m_pEffect = NULL;
  67.     m_pTextSprite = NULL;
  68.     m_pBackgroundTexture = NULL;
  69.     m_pEnvironmentTexture = NULL;
  70.     m_dwBackgroundColor = D3DCOLOR_ARGB(0, 0, 0, 255);
  71.     m_pVBBackground = NULL;
  72.     m_iTechnique = -1;
  73.     m_iPass = -1;
  74.     m_strMesh[0] = 0;
  75.     m_pMesh = NULL;
  76.     m_pbufMaterials = NULL;
  77.     m_dwNumMaterials = 0;
  78.     m_ppTextures = NULL;
  79.     m_strBackgroundTexture[0] = 0;
  80.     m_vObjectCenter = D3DXVECTOR3(0, 0, 0);
  81.     m_fObjectRadius = 1.0f;
  82.     m_pMeshSphere = NULL;
  83.     m_bWireframe = FALSE;
  84.     m_bNoTextures = FALSE;
  85.     m_bSelectedPassOnly = FALSE;
  86.     m_bUpToSelectedPassOnly = FALSE;
  87.     m_bUINeedsReset = TRUE;
  88. }
  89.  
  90. CRenderView::~CRenderView()
  91. {
  92.     SAFE_RELEASE( m_pEffect );
  93.     DXUTShutdown();
  94. }
  95.  
  96. void CRenderView::DoDataExchange(CDataExchange* pDX)
  97. {
  98.     CFormView::DoDataExchange(pDX);
  99.     //{{AFX_DATA_MAP(CRenderView)
  100.         // NOTE: the ClassWizard will add DDX and DDV calls here
  101.     //}}AFX_DATA_MAP
  102. }
  103.  
  104. BOOL CRenderView::PreCreateWindow(CREATESTRUCT& cs)
  105. {
  106.     // TODO: Modify the Window class or styles here by modifying
  107.     //  the CREATESTRUCT cs
  108.  
  109.     return CFormView::PreCreateWindow(cs);
  110. }
  111.  
  112.  
  113. // DXUT Callbacks
  114. void CRenderView::OnFrameMoveCB( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime )
  115. {
  116.     if( s_pRenderView )
  117.         s_pRenderView->OnFrameMove( pd3dDevice, fTime, fElapsedTime );
  118. }
  119.  
  120.  
  121. void CRenderView::OnFrameRenderCB( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime )
  122. {
  123.     if( s_pRenderView )
  124.         s_pRenderView->OnFrameRender( pd3dDevice, fTime, fElapsedTime );
  125. }
  126.  
  127.  
  128. HRESULT CRenderView::OnCreateDeviceCB( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc )
  129. {
  130.     if( s_pRenderView )
  131.         return s_pRenderView->OnCreateDevice( pd3dDevice, pBackBufferSurfaceDesc );
  132.     return S_OK;
  133. }
  134.  
  135.  
  136. HRESULT CRenderView::OnResetDeviceCB( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc )
  137. {
  138.     if( s_pRenderView )
  139.         return s_pRenderView->OnResetDevice( pd3dDevice, pBackBufferSurfaceDesc );
  140.     return S_OK;
  141. }
  142.  
  143.  
  144. void CRenderView::OnLostDeviceCB()
  145. {
  146.     if( s_pRenderView )
  147.         s_pRenderView->OnLostDevice();
  148. }
  149.  
  150.  
  151. void CRenderView::OnDestroyDeviceCB()
  152. {
  153.     if( s_pRenderView )
  154.         s_pRenderView->OnDestroyDevice();
  155. }
  156.  
  157.  
  158. //-----------------------------------------------------------------------------
  159. // Name: FullScreenWndProc()
  160. // Desc: The WndProc funtion used when the app is in fullscreen mode. This is
  161. //       needed simply to trap the ESC key.
  162. //-----------------------------------------------------------------------------
  163. LRESULT CALLBACK FullScreenWndProc( HWND hWnd, UINT msg, WPARAM wParam,
  164.                                     LPARAM lParam )
  165. {
  166.     if( msg == WM_CREATE )
  167.     {
  168.         s_pRenderView = (CRenderView*)((CREATESTRUCT*)lParam)->lpCreateParams;
  169.     }
  170.     else if( msg == WM_CLOSE )
  171.     {
  172.         // User wants to exit, so go back to windowed mode and exit for real
  173.         s_pRenderView->OnToggleFullscreen();
  174.         s_pRenderView->GetActiveWindow()->PostMessage( WM_CLOSE, 0, 0 );
  175.         //g_App.GetMainWnd()->PostMessage( WM_CLOSE, 0, 0 );
  176.     }
  177.     else if( msg == WM_SETCURSOR )
  178.     {
  179.         SetCursor( NULL );
  180.     }
  181.     else if( ( msg == WM_KEYUP && wParam == VK_ESCAPE ) ||
  182.              ( msg == WM_SYSCHAR && wParam == VK_RETURN ) )
  183.     {
  184.         // User wants to leave fullscreen mode
  185.         s_pRenderView->OnToggleFullscreen();
  186.         return 0;
  187.     }
  188.     else if ( msg == WM_LBUTTONDOWN ||
  189.               msg == WM_LBUTTONUP ||
  190.               msg == WM_RBUTTONDOWN ||
  191.               msg == WM_RBUTTONUP ||
  192.               msg == WM_MOUSEMOVE )
  193.     {
  194.         // Map the coordinates from fullscreen window to
  195.         // RenderView window.
  196.         POINT pt = { GET_X_LPARAM( lParam ), GET_Y_LPARAM( lParam ) };
  197.         ::MapWindowPoints( hWnd, s_pRenderView->GetSafeHwnd(), &pt, 1 );
  198.         lParam = MAKELPARAM( pt.x, pt.y );
  199.  
  200.         // forward mouse messages to the render view window
  201.         s_pRenderView->PostMessage( msg, wParam, lParam );
  202.     }
  203.  
  204.     return DefWindowProc( hWnd, msg, wParam, lParam );
  205. }
  206.  
  207.  
  208. void CRenderView::OnInitialUpdate()
  209. {
  210.     CFormView::OnInitialUpdate();
  211.     GetParentFrame()->RecalcLayout();
  212.     ResizeParentToFit();
  213.  
  214.     // Save static reference to the render window
  215.     m_hwndRenderWindow = GetDlgItem(IDC_RENDERWINDOW)->GetSafeHwnd();
  216.  
  217.     // Register a class for a fullscreen window
  218.     WNDCLASS wndClass = { CS_HREDRAW | CS_VREDRAW, FullScreenWndProc, 0, 0, NULL,
  219.                           NULL, LoadCursor(NULL, IDC_ARROW), (HBRUSH)GetStockObject(WHITE_BRUSH), NULL,
  220.                           _T("Fullscreen Window") };
  221.     RegisterClass( &wndClass );
  222.  
  223.     // We create the fullscreen window (not visible) at startup, so it can
  224.     // be the focus window.  The focus window can only be set at CreateDevice
  225.     // time, not in a Reset, so ToggleFullscreen wouldn't work unless we have
  226.     // already set up the fullscreen focus window.
  227.     m_hwndRenderFullScreen = CreateWindow( _T("Fullscreen Window"), NULL,
  228.                                            WS_POPUP, 0, 0, 100, 100,
  229.                                            GetTopLevelParent()->GetSafeHwnd(), 0L, NULL, this );
  230.  
  231.     // If we haven't initialized the D3D framework, do so now
  232.     if( !DXUTGetD3DDevice() )
  233.     {
  234.         CRect rc;
  235.         ::GetClientRect( m_hwndRenderWindow, &rc );
  236.         if( rc.Width() == 0 || rc.Height() == 0 )
  237.         {
  238.             MessageBox( TEXT("The render view must be visible when EffectEdit starts.  Please change the window size or splitters and start EffectEdit again."),
  239.                 TEXT("EffectEdit") );
  240.         }
  241.         else
  242.         {
  243.             // Set up the DXUT callbacks
  244.             DXUTSetCallbackDeviceCreated( OnCreateDeviceCB );
  245.             DXUTSetCallbackDeviceReset( OnResetDeviceCB );
  246.             DXUTSetCallbackDeviceLost( OnLostDeviceCB );
  247.             DXUTSetCallbackDeviceDestroyed( OnDestroyDeviceCB );
  248.             DXUTSetCallbackFrameRender( OnFrameRenderCB );
  249.             DXUTSetCallbackFrameMove( OnFrameMoveCB );
  250.  
  251.             // Show the cursor and clip it when in full screen
  252.             DXUTSetCursorSettings( true, true );
  253.  
  254.             DXUTInit( true, true, true ); // Parse the command line, handle the default hotkeys, and show msgboxes
  255.  
  256.             // Note that for the MFC samples, the device window and focus window
  257.             // are not the same.
  258.             DXUTSetWindow( m_hwndRenderFullScreen, m_hwndRenderFullScreen, m_hwndRenderWindow, false );
  259.             ::GetClientRect( m_hwndRenderWindow, &m_rcWindowClient );
  260.             HRESULT hr = DXUTCreateDevice( D3DADAPTER_DEFAULT, true, m_rcWindowClient.right - m_rcWindowClient.left,
  261.                                            m_rcWindowClient.bottom - m_rcWindowClient.top, NULL, NULL );
  262.             if( FAILED( hr ) )
  263.             {
  264.                 // If D3D is not functional, do not continue.  End the application now.
  265.                 CFrameWnd *pTop = this->GetTopLevelFrame();
  266.                 if( pTop )
  267.                     pTop->PostMessage( WM_CLOSE, 0, 0 );
  268.             }
  269.         }
  270.     }
  271.     GetDocument()->Compile();
  272. }
  273.  
  274. /////////////////////////////////////////////////////////////////////////////
  275. // CRenderView diagnostics
  276.  
  277. #ifdef _DEBUG
  278. void CRenderView::AssertValid() const
  279. {
  280.     CFormView::AssertValid();
  281. }
  282.  
  283.  
  284. void CRenderView::Dump(CDumpContext& dc) const
  285. {
  286.     CFormView::Dump(dc);
  287. }
  288.  
  289.  
  290. CEffectDoc* CRenderView::GetDocument() // non-debug version is inline
  291. {
  292.     ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CEffectDoc)));
  293.     return (CEffectDoc*)m_pDocument;
  294. }
  295. #endif //_DEBUG
  296.  
  297.  
  298. void CRenderView::OnFrameMove( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime )
  299. {
  300.      // Setup world matrix
  301.     D3DXMatrixTranslation( &m_matWorld, -m_vObjectCenter.x,
  302.                                       -m_vObjectCenter.y,
  303.                                       -m_vObjectCenter.z );
  304.     D3DXMatrixMultiply( &m_matWorld, &m_matWorld, m_ArcBallMesh.GetRotationMatrix() );
  305.     D3DXMatrixMultiply( &m_matWorld, &m_matWorld, m_ArcBallMesh.GetTranslationMatrix() );
  306.     pd3dDevice->SetTransform( D3DTS_WORLD, &m_matWorld );
  307.  
  308.     D3DXVECTOR3 vFrom( 0, 0, -2*m_fObjectRadius );
  309.     D3DXVECTOR3 vAt( 0, 0, 0 );
  310.     D3DXVECTOR3 vUp( 0, 1, 0 );
  311.     D3DXMatrixLookAtLH( &m_matView, &vFrom, &vAt, &vUp );
  312.     D3DXMatrixMultiply( &m_matView, m_ArcBallView.GetRotationMatrix(), &m_matView );
  313.     D3DXMatrixMultiply( &m_matView, &m_matView, m_ArcBallView.GetTranslationMatrix() );
  314.     pd3dDevice->SetTransform( D3DTS_VIEW, &m_matView );
  315.     
  316.     m_UIElements.SetMatView( &m_matView );
  317.     m_UIElements.SetObjectRadius( m_fObjectRadius );
  318. }
  319.  
  320. // Vertex data for a cube that is used to draw the environment
  321. //   3D Positon and 3D texture coordinate for lookup in cube map
  322. static CUBEBACKGROUNDVERTEX EnvironmentVerts[] =
  323. {
  324.     { 1.0f,  1.0f, 1.0f, 1.0f, 1.0f, 1.0f},
  325.     { 1.0f,  1.0f,-1.0f, 1.0f, 1.0f,-1.0f},
  326.     { 1.0f, -1.0f, 1.0f, 1.0f,-1.0f, 1.0f},
  327.     { 1.0f, -1.0f,-1.0f, 1.0f,-1.0f,-1.0f},
  328.     {-1.0f,  1.0f, 1.0f,-1.0f, 1.0f, 1.0f},
  329.     {-1.0f,  1.0f,-1.0f,-1.0f, 1.0f,-1.0f},
  330.     {-1.0f, -1.0f, 1.0f,-1.0f,-1.0f, 1.0f},
  331.     {-1.0f, -1.0f,-1.0f,-1.0f,-1.0f,-1.0f},
  332. };
  333.  
  334. //  index data for the cube to draw the environment with
  335. static WORD EnvironmentIndices[] =
  336. {
  337.     0, 1, 3,  0, 3, 2,   4, 7, 5,  4, 6, 7,
  338.     0, 2, 6,  0, 6, 4,   1, 7, 3,  1, 5, 7,
  339.     0, 5, 1,  0, 4, 5,   2, 3, 7,  2, 7, 6
  340. };
  341.  
  342. void CRenderView::OnFrameRender( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime )
  343. {
  344.     HRESULT hr;
  345.  
  346.     // Clear the viewport
  347.     pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
  348.                        m_dwBackgroundColor, 1.0f, 0L );
  349.     if( SUCCEEDED( hr = pd3dDevice->BeginScene() ) )
  350.     {
  351.         if( m_pEffect != NULL )
  352.         {
  353.             if (m_pEnvironmentTexture != NULL)
  354.             {
  355.                 // set the rotation of the environment
  356.                 // Note: EffectEdit always shows the environment cubemap aligned with world
  357.                 // space (world matrix is identity), but some apps might want to support
  358.                 // a rotated cubemap.
  359.                 D3DXMATRIXA16 matWorldEnvMap;
  360.                 D3DXMatrixIdentity(&matWorldEnvMap);
  361.                 pd3dDevice->SetTransform( D3DTS_WORLD, &matWorldEnvMap);
  362.                 pd3dDevice->SetTransform( D3DTS_VIEW, m_ArcBallView.GetRotationMatrix() );
  363.  
  364.                 // Render background image
  365.                 pd3dDevice->SetTexture(0, m_pEnvironmentTexture);
  366.                 pd3dDevice->SetRenderState( D3DRS_ZENABLE, FALSE );
  367.                 pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID);
  368.                 pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
  369.                 pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
  370.                 pd3dDevice->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
  371.  
  372.                 pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
  373.                 pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
  374.                 pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
  375.                 pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
  376.  
  377.                 pd3dDevice->SetFVF( CUBEBACKGROUNDVERTEX::FVF);
  378.                 pd3dDevice->DrawIndexedPrimitiveUP( D3DPT_TRIANGLELIST, 0, 8, 12, EnvironmentIndices, 
  379.                     D3DFMT_INDEX16, EnvironmentVerts, sizeof(CUBEBACKGROUNDVERTEX));
  380.                 
  381.                 // restore the device state
  382.                 pd3dDevice->SetTexture(0, NULL);
  383.                 pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE);
  384.                 pd3dDevice->SetTransform( D3DTS_WORLD, &m_matWorld );
  385.                 pd3dDevice->SetTransform( D3DTS_VIEW, &m_matView );
  386.             }
  387.             else if( m_pBackgroundTexture != NULL )
  388.             {
  389.                 // Render background image
  390.                 pd3dDevice->SetTexture(0, m_pBackgroundTexture);
  391.                 pd3dDevice->SetRenderState( D3DRS_ZENABLE, FALSE );
  392.                 pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );
  393.                 pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
  394.                 pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
  395.  
  396.                 pd3dDevice->SetFVF( FLATBACKGROUNDVERTEX::FVF);
  397.                 pd3dDevice->SetStreamSource( 0, m_pVBBackground, 0, 6*sizeof(float) );
  398.                 pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 2 );
  399.                 
  400.                 pd3dDevice->SetTexture(0, NULL);
  401.                 pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
  402.             }
  403.  
  404.             // Render the mesh with the current effect
  405.             if( m_pEffect != NULL )
  406.             {
  407.                 if( m_MatWorldEffectHandle != NULL )
  408.                     m_pEffect->SetMatrix( m_MatWorldEffectHandle, &m_matWorld );
  409.  
  410.                 if( m_MatViewEffectHandle != NULL )
  411.                     m_pEffect->SetMatrix( m_MatViewEffectHandle, &m_matView );
  412.  
  413.                 if( m_MatProjEffectHandle != NULL )
  414.                     m_pEffect->SetMatrix( m_MatProjEffectHandle, &m_matProj );
  415.  
  416.                 if( m_MatWorldViewEffectHandle != NULL )
  417.                 {
  418.                     D3DXMATRIX matWorldView = m_matWorld * m_matView;
  419.                     m_pEffect->SetMatrix( m_MatWorldViewEffectHandle, &matWorldView );
  420.                 }
  421.  
  422.                 if( m_MatViewProjEffectHandle != NULL )
  423.                 {
  424.                     D3DXMATRIX matViewProj = m_matView * m_matProj;
  425.                     m_pEffect->SetMatrix( m_MatViewProjEffectHandle, &matViewProj );
  426.                 }
  427.  
  428.                 if( m_MatWorldViewProjEffectHandle != NULL )
  429.                 {
  430.                     D3DXMATRIX matWorldViewProj = m_matWorld * m_matView * m_matProj;
  431.                     m_pEffect->SetMatrix( m_MatWorldViewProjEffectHandle, &matWorldViewProj );
  432.                 }
  433.  
  434.                 if( m_VecCameraPosEffectHandle != NULL )
  435.                 {
  436.                     D3DXMATRIXA16 matViewInv;
  437.                     D3DXMatrixInverse( &matViewInv, NULL, &m_matView );
  438.                     D3DXVECTOR4 vecPosition( matViewInv._41, matViewInv._42, matViewInv._43, 1.0f );
  439.                     m_pEffect->SetVector( m_VecCameraPosEffectHandle, &vecPosition );
  440.                 }
  441.  
  442.                 if( m_TimeEffectHandle != NULL )
  443.                     m_pEffect->SetFloat( m_TimeEffectHandle, float(fTime) );
  444.  
  445.                 if( m_MeshRadiusEffectHandle != NULL )
  446.                     m_pEffect->SetFloat( m_MeshRadiusEffectHandle, m_fObjectRadius );
  447.  
  448.                 m_UIElements.SetEffectParameters( m_pEffect );
  449.  
  450.                 D3DCAPS9 d3dCaps;
  451.                 pd3dDevice->GetDeviceCaps( &d3dCaps );
  452.  
  453.                 UINT numPasses;
  454.                 hr = m_pEffect->Begin( &numPasses, 0 );
  455.  
  456.                 if( SUCCEEDED( hr ) )
  457.                 {
  458.                     for( UINT iPass = 0; iPass < numPasses; iPass++ )
  459.                     {
  460.                         if( m_bSelectedPassOnly )
  461.                             iPass = m_iPass;
  462.  
  463.                         hr = m_pEffect->BeginPass( iPass );
  464.                         
  465.                         if( m_bWireframe )
  466.                             pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME );
  467.                         else
  468.                             pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );
  469.                         
  470.                         if( m_bNoTextures )
  471.                         {
  472.                             for( UINT iStage = 0; iStage < d3dCaps.MaxTextureBlendStages; iStage++ )
  473.                                 pd3dDevice->SetTexture( iStage, NULL );
  474.                         }
  475.  
  476.                         if( m_pMesh == NULL )
  477.                         {
  478.                             m_pMeshSphere->DrawSubset( 0 );
  479.                         }
  480.                         else
  481.                         {
  482.                             for( UINT i = 0; i < m_dwNumMaterials; i++ )
  483.                             {
  484.                                 if( m_MaterialAmbientEffectHandle != NULL )
  485.                                     m_pEffect->SetVector( m_MaterialAmbientEffectHandle, (LPD3DXVECTOR4)&m_pMaterials[i].MatD3D.Ambient );
  486.                                 if( m_MaterialDiffuseEffectHandle != NULL )
  487.                                     m_pEffect->SetVector( m_MaterialDiffuseEffectHandle, (LPD3DXVECTOR4)&m_pMaterials[i].MatD3D.Diffuse );
  488.                                 if( m_MaterialSpecularEffectHandle != NULL )
  489.                                     m_pEffect->SetVector( m_MaterialSpecularEffectHandle, (LPD3DXVECTOR4)&m_pMaterials[i].MatD3D.Specular );
  490.                                 if( m_MaterialSpecularPowerEffectHandle != NULL )
  491.                                     m_pEffect->SetFloat( m_MaterialSpecularPowerEffectHandle, m_pMaterials[i].MatD3D.Power );
  492.                                 m_pEffect->CommitChanges();                           
  493.                                 m_pMesh->DrawSubset( i );
  494.                             }
  495.                         }
  496.  
  497.                         hr = m_pEffect->EndPass();
  498.  
  499.                         if( m_bSelectedPassOnly || ( m_bUpToSelectedPassOnly && (int)iPass == m_iPass ) )
  500.                             break;
  501.                     }
  502.  
  503.                     hr = m_pEffect->End();
  504.                 }
  505.  
  506.                 // Render the UI objects
  507.                 m_UIElements.Render( pd3dDevice );
  508.  
  509.             }
  510.  
  511.         }
  512.  
  513.         if( m_bShowStats )
  514.         {
  515.             CDXUTTextHelper txtHelper( m_pFont, m_pTextSprite, 15 );
  516.  
  517.             txtHelper.Begin();
  518.             // Output statistics
  519.             txtHelper.SetInsertionPos( 5, 5 );
  520.             txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 0.0f, 1.0f ) );
  521.             txtHelper.DrawTextLine( DXUTGetFrameStats() );
  522.             txtHelper.DrawTextLine( DXUTGetDeviceStats() );
  523.             if( m_pEffect == NULL )
  524.             {
  525.                 txtHelper.SetForegroundColor( D3DXCOLOR(1.0f, 0.0f, 0.0f, 1.0f ) );
  526.                 txtHelper.DrawTextLine( L"Error in effect file" );
  527.             }
  528.  
  529.             if( !m_bTechniqueValidValid )
  530.             {
  531.                 m_bTechniqueValid = SUCCEEDED( m_pEffect->ValidateTechnique( m_pEffect->GetCurrentTechnique() ) );
  532.                 m_bTechniqueValidValid = TRUE;
  533.             }
  534.  
  535.             if( !m_bTechniqueValid )
  536.             {
  537.                 txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 0.0f, 0.0f, 1.0f ) );
  538.                 txtHelper.SetInsertionPos( 2, 45 );
  539.                 txtHelper.DrawTextLine( L"Warning: technique not valid with current device settings" );
  540.             }
  541.  
  542.             if( !((CEffectEditApp*)AfxGetApp())->AppActivated() )
  543.             {
  544.                 txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f ) );
  545.                 txtHelper.SetInsertionPos( 2, 60 );
  546.                 txtHelper.DrawTextLine( L"Note: sleeping between frames because app is not frontmost, fps may be lower" );
  547.             }
  548.  
  549.             txtHelper.End();
  550.         }
  551.         // End the scene.
  552.         pd3dDevice->EndScene();
  553.     }
  554. }
  555.  
  556.  
  557. /////////////////////////////////////////////////////////////////////////////
  558. // CRenderView message handlers
  559.  
  560. void CRenderView::OnDestroy()
  561. {
  562.     ::DestroyWindow( m_hwndRenderFullScreen );
  563. }
  564.  
  565.  
  566. void CRenderView::OnSize(UINT nType, int cx, int cy) 
  567. {
  568.     SetScrollSizes( MM_TEXT, CSize(cx, cy) );
  569.  
  570.     CFormView::OnSize(nType, cx, cy);
  571.     
  572.     CWnd* pGroup = GetDlgItem(IDC_GROUPBOX);
  573.     CWnd* pRenderWnd = GetDlgItem(IDC_RENDERWINDOW);
  574.     CWnd* pRenderText = GetDlgItem(IDC_RENDERTEXT);
  575.  
  576.     if( pGroup != NULL && 
  577.         pRenderWnd != NULL &&
  578.         pRenderText != NULL )
  579.     {
  580.         CRect rc;
  581.         INT textHeight;
  582.         pRenderText->GetClientRect(&rc);
  583.         textHeight = rc.Height();
  584.  
  585.         pRenderText->SetWindowPos(NULL, 0, cy - textHeight - 5, cx, textHeight, SWP_NOZORDER);
  586.         pRenderText->Invalidate();
  587.         pGroup->SetWindowPos(NULL, 7, 2, cx - 7 - 4, cy - textHeight - 2 - 10, SWP_NOZORDER);
  588.  
  589.         pGroup->GetClientRect(&rc);
  590.         pGroup->MapWindowPoints(this, &rc);
  591.  
  592.  
  593.         RECT rcClientOld = m_rcWindowClient;
  594.         
  595.         rc.InflateRect( -10, -17, -10, -10 );
  596.         pRenderWnd->SetWindowPos(NULL, rc.left, rc.top, rc.Width(), rc.Height(), SWP_NOZORDER);
  597.  
  598.         if( DXUTGetD3DDevice() != NULL )
  599.         {
  600.             pRenderWnd->GetClientRect( &m_rcWindowClient );
  601.             DXUTStaticWndProc( GetSafeHwnd(), WM_SIZE, nType, MAKELPARAM( cx, cy ) );
  602.             DXUTStaticWndProc( GetSafeHwnd(), WM_EXITSIZEMOVE, 0, 0 );
  603.         }
  604.     }
  605. }
  606.  
  607.  
  608. void CRenderView::OnRender() 
  609. {
  610.     if( DXUTGetD3DDevice() != NULL )
  611.         DXUTRender3DEnvironment();
  612. }
  613.  
  614.  
  615. HRESULT CRenderView::OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc )
  616. {
  617.     HRESULT hr;
  618.  
  619.     // Initialize the font
  620.     if( FAILED( hr = D3DXCreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET, 
  621.                                      OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, 
  622.                                      _T("Arial"), &m_pFont ) ) )
  623.         return hr;
  624.  
  625.     if( FAILED( hr = D3DXCreateSphere( pd3dDevice, 1.0f, 40, 40, &m_pMeshSphere, NULL ) ) )
  626.         return hr;
  627.  
  628.     if( FAILED( hr = m_UIElements.OnCreateDevice( pd3dDevice ) ) )
  629.         return hr;
  630.  
  631.     if( GetDocument()->GetCode().GetLength() > 0 )
  632.         GetDocument()->Compile( true );
  633.  
  634.     return S_OK;
  635. }
  636.  
  637. void CRenderView::OnDestroyDevice()
  638. {
  639.     SAFE_RELEASE( m_pFont );
  640.     SAFE_RELEASE( m_pBackgroundTexture );
  641.     SAFE_RELEASE( m_pEnvironmentTexture );
  642.     SAFE_RELEASE( m_pMeshSphere );
  643.     m_UIElements.OnDestroyDevice();
  644.     UnloadMesh();
  645.     SAFE_RELEASE( m_pEffect );
  646. }
  647.  
  648.  
  649. HRESULT CRenderView::OnResetDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc )
  650. {
  651.     HRESULT hr;
  652.  
  653.     if( FAILED( hr = m_pFont->OnResetDevice() ) )
  654.         return hr;
  655.  
  656.     // Create a sprite to help batch calls when drawing many lines of text
  657.     if( FAILED( hr = D3DXCreateSprite( pd3dDevice, &m_pTextSprite ) ) )
  658.         return hr;
  659.  
  660.     if( FAILED( hr = m_UIElements.OnResetDevice( pd3dDevice ) ) )
  661.         return hr;
  662.  
  663.     // Build background image vertex buffer
  664.     if ( FAILED( hr = pd3dDevice->CreateVertexBuffer( sizeof(FLATBACKGROUNDVERTEX)*4, 0,
  665.         FLATBACKGROUNDVERTEX::FVF, D3DPOOL_MANAGED, &m_pVBBackground, NULL ) ) )
  666.     {
  667.         return hr;
  668.     }
  669.  
  670.     //set up a set of points which represents the screen
  671.     static struct { float x,y,z,w; float u,v; } s_Verts[] =
  672.     {
  673.         {750.0f,  -0.5f, 0.5f, 1.0f, 1,0},
  674.         {750.0f, 750.0f, 0.5f, 1.0f, 1,1},
  675.         { -0.5f,  -0.5f, 0.5f, 1.0f, 0,0},
  676.         { -0.5f, 750.0f, 0.5f, 1.0f, 0,1},
  677.     };
  678.  
  679.     s_Verts[0].x = (float)pBackBufferSurfaceDesc->Width - 0.5f;
  680.     s_Verts[1].x = (float)pBackBufferSurfaceDesc->Width - 0.5f;
  681.     s_Verts[1].y = (float)pBackBufferSurfaceDesc->Height - 0.5f;
  682.     s_Verts[3].y = (float)pBackBufferSurfaceDesc->Height - 0.5f; 
  683.  
  684.     //copy them into the buffer
  685.     void *pVerts;
  686.     if ( FAILED(hr = m_pVBBackground->Lock( 0, sizeof(s_Verts), (void**)&pVerts, 0 )) )
  687.         return hr;
  688.  
  689.     memcpy( pVerts, s_Verts, sizeof(s_Verts) );
  690.  
  691.     m_pVBBackground->Unlock();
  692.  
  693.     if( m_pEffect != NULL )
  694.         m_pEffect->OnResetDevice();
  695.  
  696.     // Setup the arcball parameters
  697.     m_ArcBallMesh.SetWindow( pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height, 0.85f );
  698.     m_ArcBallView.SetWindow( pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height, 0.85f );
  699.  
  700.     // Setup the projection matrix
  701.     FLOAT      fAspect = (FLOAT)pBackBufferSurfaceDesc->Width / (FLOAT)pBackBufferSurfaceDesc->Height;
  702.     D3DXMatrixPerspectiveFovLH( &m_matProj, D3DX_PI/4, fAspect, 
  703.                                 m_fObjectRadius/64.0f, m_fObjectRadius*64.0f );
  704.     pd3dDevice->SetTransform( D3DTS_PROJECTION, &m_matProj );
  705.  
  706.     m_UIElements.SetInfo( pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height, &m_matProj );
  707.  
  708.     return S_OK;
  709. }
  710.  
  711.  
  712. void CRenderView::OnLostDevice()
  713. {
  714.     m_pFont->OnLostDevice();
  715.  
  716.     m_UIElements.OnLostDevice();
  717.  
  718.     SAFE_RELEASE( m_pVBBackground );
  719.  
  720.     if( m_pEffect != NULL )
  721.         m_pEffect->OnLostDevice();
  722.  
  723.     SAFE_RELEASE( m_pTextSprite );
  724. }
  725.  
  726.  
  727. // Helper class for D3DXCreateEffect() to be able to load include files
  728. class CIncludeManager : public ID3DXInclude
  729. {
  730. protected:
  731.     CRenderView* m_pView;
  732.  
  733. public:
  734.     CIncludeManager( CRenderView* pView ) { m_pView = pView; }
  735.     STDMETHOD(Open)(D3DXINCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes);
  736.     STDMETHOD(Close)(LPCVOID pData);
  737. };
  738.  
  739.  
  740. HRESULT CIncludeManager::Open(D3DXINCLUDE_TYPE IncludeType, LPCSTR pName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes)
  741. {
  742.     CFile f;
  743.     WCHAR strFile[MAX_PATH];
  744.     WCHAR strFileFull[MAX_PATH];
  745.  
  746.     MultiByteToWideChar( CP_ACP, 0, pName, -1, strFile, MAX_PATH );
  747.  
  748.     if( FAILED( m_pView->EE_FindMediaFileCch( strFileFull, MAX_PATH, strFile ) ) )
  749.         return E_FAIL;
  750.  
  751.     if( !f.Open( strFileFull, CFile::modeRead ) ) 
  752.         return E_FAIL;
  753.  
  754.     UINT size = (UINT)f.GetLength();
  755.  
  756.     BYTE* pData = new BYTE[size];
  757.     if( pData == NULL )
  758.         return E_OUTOFMEMORY;
  759.  
  760.     f.Read( pData, size );
  761.  
  762.     *ppData = pData;
  763.     *pBytes = size;
  764.  
  765.     return S_OK;
  766. }
  767.  
  768.  
  769. HRESULT CIncludeManager::Close(LPCVOID pData)
  770. {
  771.     BYTE* pData2 = (BYTE*)pData;
  772.     SAFE_DELETE_ARRAY( pData2 );
  773.     return S_OK;
  774. }
  775.  
  776.  
  777. HRESULT CRenderView::CompileEffect(CString strEffect, BOOL bUseShaderOptimizations, BOOL bFromFile, CString &strErrors, 
  778.                                    CStringList& techniqueNameList, int* piTechnique, BOOL* pbTryLater)
  779. {
  780.     HRESULT hr = S_OK;
  781.     LPD3DXBUFFER pBufferErrors = NULL;
  782.     CIncludeManager includeManager(this);
  783.  
  784.     *pbTryLater = FALSE;
  785.  
  786.     if( DXUTGetD3DDevice() == NULL )
  787.     {
  788.         *pbTryLater = TRUE;
  789.         return E_FAIL;
  790.     }
  791.  
  792.     SAFE_RELEASE( m_pEffect );
  793.     m_MatWorldEffectHandle = NULL;
  794.     m_MatViewEffectHandle = NULL;
  795.     m_MatProjEffectHandle = NULL;
  796.     m_MatWorldViewEffectHandle = NULL;
  797.     m_MatViewProjEffectHandle = NULL;
  798.     m_MatWorldViewProjEffectHandle = NULL;
  799.     m_VecCameraPosEffectHandle = NULL;
  800.     m_MaterialAmbientEffectHandle = NULL;
  801.     m_MaterialDiffuseEffectHandle = NULL;
  802.     m_MaterialSpecularEffectHandle = NULL;
  803.     m_MaterialSpecularPowerEffectHandle = NULL;
  804.     m_TimeEffectHandle = NULL;
  805.     m_MeshRadiusEffectHandle = NULL;
  806.  
  807.     if( m_bUINeedsReset )
  808.     {
  809.         m_UIElements.DeleteAllElements();
  810.         ResetCamera();
  811.         UnloadMesh();
  812.         m_fObjectRadius = 1.0f;
  813.         m_vObjectCenter.x = 0;
  814.         m_vObjectCenter.y = 0;
  815.         m_vObjectCenter.z = 0;
  816.         // Adjust near/far clip planes of projection matrix based on the object radius
  817.         const D3DSURFACE_DESC *pBackBufferDesc = DXUTGetBackBufferSurfaceDesc();
  818.         FLOAT fAspect = (FLOAT)pBackBufferDesc->Width / (FLOAT)pBackBufferDesc->Height;
  819.         D3DXMatrixPerspectiveFovLH( &m_matProj, D3DX_PI/4, fAspect, 
  820.                                     m_fObjectRadius/64.0f, m_fObjectRadius*64.0f );
  821.         DXUTGetD3DDevice()->SetTransform( D3DTS_PROJECTION, &m_matProj );
  822.         m_bUINeedsReset = FALSE;
  823.     }
  824.     else
  825.     {
  826.         // Delete all effect handles inside UI elements, but keep their other state
  827.         m_UIElements.DeleteEffectObjects();
  828.     }
  829.  
  830.     techniqueNameList.RemoveAll();
  831.     GetDlgItem(IDC_RENDERTEXT)->SetWindowText( TEXT("(nothing to render)") );
  832.  
  833.     DWORD dwFlags = D3DXSHADER_DEBUG;
  834.     if( !bUseShaderOptimizations )
  835.         dwFlags |= D3DXSHADER_SKIPOPTIMIZATION;
  836.  
  837.     if( !bFromFile )
  838.     {
  839.         UINT EffectLength = strEffect.GetLength();
  840.         char* strEffectA = new char[EffectLength + 1];
  841.         if( strEffectA == NULL )
  842.             return E_OUTOFMEMORY;
  843.         WideCharToMultiByte( CP_ACP, 0, strEffect, -1, strEffectA, EffectLength + 1, NULL, NULL );
  844.         
  845.         hr = D3DXCreateEffect( DXUTGetD3DDevice(), strEffectA, EffectLength, NULL, 
  846.                                &includeManager, dwFlags, NULL, &m_pEffect, &pBufferErrors );
  847.  
  848.         delete[] strEffectA;
  849.     }
  850.     else
  851.     {
  852.         hr = D3DXCreateEffectFromFile( DXUTGetD3DDevice(), strEffect, NULL, &includeManager, dwFlags, NULL, &m_pEffect, &pBufferErrors );
  853.     }
  854.  
  855.     if( pBufferErrors != NULL )
  856.         strErrors = (CHAR*)pBufferErrors->GetBufferPointer();
  857.     else
  858.         strErrors.Empty();
  859.  
  860.     SAFE_RELEASE( pBufferErrors );
  861.  
  862.     if( m_pEffect != NULL )
  863.     {
  864.         m_pEffect->GetDesc( &m_EffectDesc );
  865.  
  866.         ParseParameters( strErrors );
  867.  
  868.         // Look for UI elements
  869.         m_UIElements.InitEffectObjects( m_pEffect );
  870.  
  871.         if( m_EffectDesc.Techniques == 0 )
  872.             m_iTechnique = -1;
  873.         else if( (UINT)m_iTechnique >= m_EffectDesc.Techniques )
  874.             m_iTechnique = 0;
  875.         else if( m_iTechnique == -1 )
  876.             m_iTechnique = 0;
  877.         *piTechnique = m_iTechnique;
  878.  
  879.         for( UINT iTech = 0; iTech < m_EffectDesc.Techniques; iTech++ )
  880.         {
  881.             D3DXTECHNIQUE_DESC desc;
  882.             m_pEffect->GetTechniqueDesc( m_pEffect->GetTechnique( iTech ), &desc );
  883.             techniqueNameList.AddTail(desc.Name);
  884.         }
  885.     }
  886.  
  887.     if( strErrors.IsEmpty() )
  888.         strErrors = TEXT("Effect compilation successful\n");
  889.  
  890.     return hr;
  891. }
  892.  
  893.  
  894. HRESULT CRenderView::ParseParameters(CString &strErrors)
  895. {
  896.     HRESULT hr;
  897.     D3DXPARAMETER_DESC Desc;
  898.  
  899.     if( m_pEffect == NULL )
  900.         return E_FAIL;
  901.  
  902.     //look for background Texture
  903.     const char* pstrBackTexture;
  904.     SAFE_RELEASE( m_pBackgroundTexture );
  905.     if( NULL != m_pEffect->GetParameterByName( NULL, "BIMG" ) &&
  906.         SUCCEEDED( m_pEffect->GetParameterDesc( "BIMG", &Desc ) ) &&
  907.         Desc.Type == D3DXPT_STRING )
  908.     {
  909.         m_pEffect->GetString("BIMG", &pstrBackTexture);
  910.         WCHAR strBackTexture[MAX_PATH];
  911.         MultiByteToWideChar( CP_ACP, 0, pstrBackTexture, -1, strBackTexture, MAX_PATH );
  912.         TCHAR strPath[MAX_PATH];
  913.         EE_FindMediaFileCch( strPath, MAX_PATH, strBackTexture );
  914.         if( FAILED( hr = D3DXCreateTextureFromFile( DXUTGetD3DDevice(), strPath, &m_pBackgroundTexture) ) )
  915.         {
  916.             strErrors += TEXT("Could not load background image texture ");
  917.             strErrors += strBackTexture;
  918.             strErrors += TEXT("\n");
  919.         }
  920.     }
  921.     // look for background environment Texture
  922.     SAFE_RELEASE( m_pEnvironmentTexture );
  923.     if( NULL != m_pEffect->GetParameterByName( NULL, "Environment" ) &&
  924.         SUCCEEDED( m_pEffect->GetParameterDesc( "Environment", &Desc ) ) &&
  925.         Desc.Type == D3DXPT_STRING )
  926.     {
  927.         m_pEffect->GetString("Environment", &pstrBackTexture);
  928.         TCHAR strBackTexture[MAX_PATH];
  929.         MultiByteToWideChar( CP_ACP, 0, pstrBackTexture, -1, strBackTexture, MAX_PATH );
  930.         TCHAR strPath[MAX_PATH];
  931.         EE_FindMediaFileCch( strPath, MAX_PATH, strBackTexture );
  932.         if( FAILED( hr = D3DXCreateCubeTextureFromFile( DXUTGetD3DDevice(), strPath, &m_pEnvironmentTexture) ) )
  933.         {
  934.             strErrors += TEXT("Could not load environment cube texture ");
  935.             strErrors += strBackTexture;
  936.             strErrors += TEXT("\n");
  937.         }
  938.     }
  939.  
  940.     // Look at parameters for semantics and annotations that we know how to interpret
  941.     D3DXPARAMETER_DESC ParamDesc;
  942.     D3DXPARAMETER_DESC AnnotDesc;
  943.     D3DXHANDLE hParam;
  944.     D3DXHANDLE hAnnot;
  945.     TCHAR strPath[MAX_PATH];
  946.     LPDIRECT3DBASETEXTURE9 pTex = NULL;
  947.  
  948.     for( UINT iParam = 0; iParam < m_EffectDesc.Parameters; iParam++ )
  949.     {
  950.         LPCSTR pstrName = NULL;
  951.         LPCSTR pstrFunction = NULL;
  952.         LPCSTR pstrTarget = NULL;
  953.         LPCSTR pstrTextureType = NULL;
  954.         INT Width = D3DX_DEFAULT;
  955.         INT Height= D3DX_DEFAULT;
  956.         INT Depth = D3DX_DEFAULT;
  957.  
  958.         hParam = m_pEffect->GetParameter ( NULL, iParam );
  959.         m_pEffect->GetParameterDesc( hParam, &ParamDesc );
  960.         if( ParamDesc.Semantic != NULL && 
  961.             ( ParamDesc.Class == D3DXPC_MATRIX_ROWS || ParamDesc.Class == D3DXPC_MATRIX_COLUMNS ) )
  962.         {
  963.             if( _strcmpi( ParamDesc.Semantic, "world" ) == 0 )
  964.                 m_MatWorldEffectHandle = hParam;
  965.             else if( _strcmpi( ParamDesc.Semantic, "view" ) == 0 )
  966.                 m_MatViewEffectHandle = hParam;
  967.             else if( _strcmpi( ParamDesc.Semantic, "projection" ) == 0 )
  968.                 m_MatProjEffectHandle = hParam;
  969.             else if( _strcmpi( ParamDesc.Semantic, "worldview" ) == 0 )
  970.                 m_MatWorldViewEffectHandle = hParam;
  971.             else if( _strcmpi( ParamDesc.Semantic, "viewprojection" ) == 0 )
  972.                 m_MatViewProjEffectHandle = hParam;
  973.             else if( _strcmpi( ParamDesc.Semantic, "worldviewprojection" ) == 0 )
  974.                 m_MatWorldViewProjEffectHandle = hParam;
  975.         }
  976.  
  977.         if( ParamDesc.Semantic != NULL && 
  978.             ( ParamDesc.Class == D3DXPC_VECTOR ))
  979.         {
  980.             if( _strcmpi( ParamDesc.Semantic, "materialambient" ) == 0 )
  981.                 m_MaterialAmbientEffectHandle = hParam;
  982.             else if( _strcmpi( ParamDesc.Semantic, "materialdiffuse" ) == 0 )
  983.                 m_MaterialDiffuseEffectHandle = hParam;
  984.             else if( _strcmpi( ParamDesc.Semantic, "materialspecular" ) == 0 )
  985.                 m_MaterialSpecularEffectHandle = hParam;
  986.             else if( _strcmpi( ParamDesc.Semantic, "cameraposition" ) == 0 )
  987.                 m_VecCameraPosEffectHandle = hParam;
  988.         }
  989.  
  990.         if( ParamDesc.Semantic != NULL && 
  991.             ( ParamDesc.Class == D3DXPC_SCALAR ))
  992.         {
  993.             if( _strcmpi( ParamDesc.Semantic, "materialpower" ) == 0 )
  994.                 m_MaterialSpecularPowerEffectHandle = hParam;
  995.             else if( _strcmpi( ParamDesc.Semantic, "time" ) == 0 )
  996.                 m_TimeEffectHandle = hParam;
  997.             else if( _strcmpi( ParamDesc.Semantic, "meshradius" ) == 0 )
  998.                 m_MeshRadiusEffectHandle = hParam;
  999.         }
  1000.  
  1001.         for( UINT iAnnot = 0; iAnnot < ParamDesc.Annotations; iAnnot++ )
  1002.         {
  1003.             hAnnot = m_pEffect->GetAnnotation ( hParam, iAnnot );
  1004.             m_pEffect->GetParameterDesc( hAnnot, &AnnotDesc );
  1005.             if( _strcmpi( AnnotDesc.Name, "name" ) == 0 )
  1006.                 m_pEffect->GetString( hAnnot, &pstrName );
  1007.             else if ( _strcmpi( AnnotDesc.Name, "function" ) == 0 )
  1008.                 m_pEffect->GetString( hAnnot, &pstrFunction );
  1009.             else if ( _strcmpi( AnnotDesc.Name, "target" ) == 0 )
  1010.                 m_pEffect->GetString( hAnnot, &pstrTarget );
  1011.             else if ( _strcmpi( AnnotDesc.Name, "width" ) == 0 )
  1012.                 m_pEffect->GetInt( hAnnot, &Width );
  1013.             else if ( _strcmpi( AnnotDesc.Name, "height" ) == 0 )
  1014.                 m_pEffect->GetInt( hAnnot, &Height );
  1015.             else if ( _strcmpi( AnnotDesc.Name, "depth" ) == 0 )
  1016.                 m_pEffect->GetInt( hAnnot, &Depth );
  1017.             else if( _strcmpi( AnnotDesc.Name, "type" ) == 0 )
  1018.                 m_pEffect->GetString( hAnnot, &pstrTextureType );
  1019.  
  1020.         }
  1021.         if( pstrName != NULL )
  1022.         {
  1023.             pTex = NULL;
  1024.             TCHAR strName[MAX_PATH];
  1025.             MultiByteToWideChar( CP_ACP, 0, pstrName, -1, strName, MAX_PATH );
  1026.             EE_FindMediaFileCch( strPath, MAX_PATH, strName );
  1027.             if (pstrTextureType != NULL) 
  1028.             {
  1029.                 if( _strcmpi( pstrTextureType, "volume" ) == 0 )
  1030.                 {
  1031.                     LPDIRECT3DVOLUMETEXTURE9 pVolumeTex = NULL;
  1032.                     if( SUCCEEDED( hr = D3DXCreateVolumeTextureFromFileEx( DXUTGetD3DDevice(), strPath, 
  1033.                         Width, Height, Depth, 1, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED,
  1034.                         D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, &pVolumeTex ) ) )
  1035.                     {
  1036.                         pTex = pVolumeTex;
  1037.                     }
  1038.                     else
  1039.                     {
  1040.                         strErrors += TEXT("Could not load volume texture ");
  1041.                         strErrors += strName;
  1042.                         strErrors += TEXT("\n");
  1043.                     }
  1044.                 }
  1045.                 else if( _strcmpi( pstrTextureType, "cube" ) == 0 )
  1046.                 {
  1047.                     LPDIRECT3DCUBETEXTURE9 pCubeTex = NULL;
  1048.                     if( SUCCEEDED( hr = D3DXCreateCubeTextureFromFileEx( DXUTGetD3DDevice(), strPath, 
  1049.                         Width, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED,
  1050.                         D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, &pCubeTex ) ) )
  1051.                     {
  1052.                         pTex = pCubeTex;
  1053.                     }
  1054.                     else
  1055.                     {
  1056.                         strErrors += TEXT("Could not load cube texture ");
  1057.                         strErrors += strName;
  1058.                         strErrors += TEXT("\n");
  1059.                     }
  1060.                 }
  1061.             }
  1062.             else
  1063.             {
  1064.                 LPDIRECT3DTEXTURE9 p2DTex = NULL;
  1065.                 if( SUCCEEDED( hr = D3DXCreateTextureFromFileEx( DXUTGetD3DDevice(), strPath, 
  1066.                     Width, Height, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED,
  1067.                     D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, &p2DTex ) ) )
  1068.                 {
  1069.                     pTex = p2DTex;
  1070.                 }
  1071.                 else
  1072.                 {
  1073.                     strErrors += TEXT("Could not load texture ");
  1074.                     strErrors += strName;
  1075.                     strErrors += TEXT("\n");
  1076.                 }
  1077.             }
  1078.  
  1079.             // Apply successfully loaded texture to effect
  1080.             if( SUCCEEDED(hr) && pTex != NULL ) 
  1081.             {
  1082.                 m_pEffect->SetTexture( m_pEffect->GetParameter( NULL, iParam ), pTex );
  1083.                 SAFE_RELEASE( pTex );
  1084.             }
  1085.         }
  1086.         else if( pstrFunction != NULL )
  1087.         {
  1088.             LPD3DXBUFFER pFunction = NULL;
  1089.             LPD3DXTEXTURESHADER pTextureShader = NULL;
  1090.             CIncludeManager includeManager(this);
  1091.             CString strEffect = GetDocument()->GetCode();
  1092.             UINT EffectLength = strEffect.GetLength();
  1093.             char* strEffectA = new char[EffectLength + 1];
  1094.             if( strEffectA == NULL )
  1095.                 return E_OUTOFMEMORY;
  1096.             WideCharToMultiByte( CP_ACP, 0, strEffect, -1, strEffectA, EffectLength + 1, NULL, NULL );
  1097.  
  1098.             if( pstrTarget == NULL )
  1099.                 pstrTarget = "tx_1_0";
  1100.  
  1101.             LPD3DXBUFFER pBufferErrors = NULL;
  1102.             if( SUCCEEDED( hr = D3DXCompileShader( strEffectA, (UINT)strlen(strEffectA), NULL, 
  1103.                 &includeManager, pstrFunction, pstrTarget, 0, &pFunction, &pBufferErrors, NULL ) ) )
  1104.             {
  1105.                 if( SUCCEEDED( hr = D3DXCreateTextureShader((DWORD *)pFunction->GetBufferPointer(), &pTextureShader) ) )
  1106.                 {
  1107.                     pTextureShader->SetDefaults();
  1108.  
  1109.                     if( Width == D3DX_DEFAULT )
  1110.                         Width = 64;
  1111.                     if( Height == D3DX_DEFAULT )
  1112.                         Height = 64;
  1113.                     if( Depth == D3DX_DEFAULT )
  1114.                         Depth = 64;
  1115.  
  1116.                     if (pstrTextureType != NULL) 
  1117.                     {
  1118.                         if( _strcmpi( pstrTextureType, "volume" ) == 0 )
  1119.                         {
  1120.                             LPDIRECT3DVOLUMETEXTURE9 pVolumeTex = NULL;
  1121.                             if( SUCCEEDED( hr = D3DXCreateVolumeTexture( DXUTGetD3DDevice(), 
  1122.                                 Width, Height, Depth, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &pVolumeTex) ) )
  1123.                             {
  1124.                                 if( SUCCEEDED( hr = D3DXFillVolumeTextureTX( pVolumeTex, pTextureShader ) ) ) 
  1125.                                     pTex = pVolumeTex;
  1126.                             }
  1127.                         }
  1128.                         else if( _strcmpi( pstrTextureType, "cube" ) == 0 )
  1129.                         {
  1130.                             LPDIRECT3DCUBETEXTURE9 pCubeTex = NULL;
  1131.                             if( SUCCEEDED( hr = D3DXCreateCubeTexture( DXUTGetD3DDevice(), 
  1132.                                 Width, D3DX_DEFAULT, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &pCubeTex) ) )
  1133.                             {
  1134.                                 if( SUCCEEDED( hr = D3DXFillCubeTextureTX( pCubeTex, pTextureShader ) ) )
  1135.                                     pTex = pCubeTex;
  1136.                             }
  1137.                         }
  1138.                     }
  1139.                     else
  1140.                     {
  1141.                         LPDIRECT3DTEXTURE9 p2DTex = NULL;
  1142.                         if( SUCCEEDED( hr = D3DXCreateTexture( DXUTGetD3DDevice(), Width, Height, 
  1143.                             D3DX_DEFAULT, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &p2DTex) ) )
  1144.                         {
  1145.                             if( SUCCEEDED( hr = D3DXFillTextureTX( p2DTex, pTextureShader ) ) )
  1146.                                 pTex = p2DTex;
  1147.                         }
  1148.                     }
  1149.                     m_pEffect->SetTexture( m_pEffect->GetParameter( NULL, iParam ), pTex );
  1150.                     SAFE_RELEASE(pTex);
  1151.                     SAFE_RELEASE(pTextureShader);
  1152.                 }
  1153.                 SAFE_RELEASE(pFunction);
  1154.             }
  1155.             if( pBufferErrors != NULL )
  1156.             {
  1157.                 strErrors += (CHAR*)pBufferErrors->GetBufferPointer();
  1158.                 pBufferErrors->Release();
  1159.             }
  1160.  
  1161.             delete[] strEffectA;
  1162.         }
  1163.     }
  1164.  
  1165.     //look for background Color
  1166.     if( NULL != m_pEffect->GetParameterByName( NULL, "BCLR" ) &&
  1167.         SUCCEEDED( m_pEffect->GetParameterDesc( "BCLR", &Desc ) ) )
  1168.         m_pEffect->GetInt("BCLR", (INT *)&m_dwBackgroundColor);
  1169.     else
  1170.         m_dwBackgroundColor = D3DCOLOR_ARGB(255, 0, 0, 255);
  1171.  
  1172.  
  1173.     // look for mesh
  1174.     if( NULL != m_pEffect->GetParameterByName( NULL, "XFile" ) &&
  1175.         SUCCEEDED( m_pEffect->GetParameterDesc( "XFile", &Desc ) ) )
  1176.     {
  1177.         const char *fileName;
  1178.     
  1179.         m_pEffect->GetString("XFile",&fileName);
  1180.         if( _strcmpi( fileName, m_strMesh ) != 0 || m_pMesh == NULL )
  1181.         {
  1182.             UnloadMesh();
  1183.             strcpy( m_strMesh, fileName ); 
  1184.             
  1185.             //load the mesh
  1186.             LoadMesh( strErrors );
  1187.         }
  1188.     }
  1189.     else
  1190.     {
  1191.         if( strlen(m_strMesh) > 0 )
  1192.         {
  1193.             // There used to be an XFile, but no longer
  1194.             UnloadMesh();
  1195.             m_strMesh[0] = NULL;
  1196.         }
  1197.     }
  1198.     BOOL bUsesTangents = FALSE;
  1199.  
  1200.     // Look for tangents semantic
  1201.     D3DXEFFECT_DESC EffectDesc;
  1202.     D3DXHANDLE hTechnique;
  1203.     D3DXTECHNIQUE_DESC TechniqueDesc;
  1204.     D3DXHANDLE hPass;
  1205.     D3DXPASS_DESC PassDesc;
  1206.  
  1207.     m_pEffect->GetDesc( &EffectDesc );
  1208.     for( UINT iTech = 0; iTech < EffectDesc.Techniques; iTech++ )
  1209.     {
  1210.         hTechnique = m_pEffect->GetTechnique( iTech );
  1211.         m_pEffect->GetTechniqueDesc( hTechnique, &TechniqueDesc );
  1212.         for( UINT iPass = 0; iPass < TechniqueDesc.Passes; iPass++ )
  1213.         {
  1214.             hPass = m_pEffect->GetPass( hTechnique, iPass );
  1215.             m_pEffect->GetPassDesc( hPass, &PassDesc );
  1216.  
  1217.             UINT NumVSSemanticsUsed;
  1218.             D3DXSEMANTIC pVSSemantics[MAXD3DDECLLENGTH];
  1219.  
  1220.             if( !PassDesc.pVertexShaderFunction ||
  1221.                 FAILED( D3DXGetShaderInputSemantics( PassDesc.pVertexShaderFunction, pVSSemantics, &NumVSSemanticsUsed ) ) )
  1222.             {
  1223.                 continue;
  1224.             }
  1225.  
  1226.             for( UINT iSem = 0; iSem < NumVSSemanticsUsed; iSem++ )
  1227.             {
  1228.                 if( pVSSemantics[iSem].Usage == D3DDECLUSAGE_TANGENT )
  1229.                 {
  1230.                     bUsesTangents = TRUE;
  1231.                     goto DoneLooking;
  1232.                 }
  1233.             }
  1234.         }
  1235.     }
  1236.  
  1237. DoneLooking:
  1238.     if( bUsesTangents && m_pMesh != NULL )
  1239.     {
  1240.         D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE];
  1241.         D3DVERTEXELEMENT9 End = D3DDECL_END();
  1242.         int iElem;
  1243.      
  1244.         m_pMesh->GetDeclaration( Declaration );
  1245.      
  1246.         BOOL bHasTangents = FALSE;
  1247.         for( iElem=0; Declaration[iElem].Stream != End.Stream; iElem++ )
  1248.         {   
  1249.             if( Declaration[iElem].Usage == D3DDECLUSAGE_TANGENT )
  1250.             {
  1251.                 bHasTangents = TRUE;
  1252.                 break;
  1253.             }
  1254.         }
  1255.      
  1256.         // Update Mesh Semantics if changed
  1257.         if( !bHasTangents ) 
  1258.         {
  1259.             Declaration[iElem].Stream = 0;
  1260.             Declaration[iElem].Offset = (WORD)m_pMesh->GetNumBytesPerVertex();
  1261.             Declaration[iElem].Type = D3DDECLTYPE_FLOAT3;
  1262.             Declaration[iElem].Method = D3DDECLMETHOD_DEFAULT;
  1263.             Declaration[iElem].Usage = D3DDECLUSAGE_TANGENT;
  1264.             Declaration[iElem].UsageIndex = 0;
  1265.             Declaration[iElem+1] = End;
  1266.             LPD3DXMESH pTempMesh;
  1267.             hr = m_pMesh->CloneMesh( D3DXMESH_MANAGED, Declaration, DXUTGetD3DDevice(), &pTempMesh );
  1268.             if( SUCCEEDED( hr ) )
  1269.             {
  1270.                 SAFE_RELEASE( m_pMesh );
  1271.                 m_pMesh = pTempMesh;
  1272.                 hr = D3DXComputeTangent( m_pMesh, 0, 0, D3DX_DEFAULT, TRUE, NULL );
  1273.             }
  1274.         }
  1275.     }
  1276.  
  1277.     return S_OK;
  1278. }
  1279.  
  1280.  
  1281. HRESULT CRenderView::LoadMesh( CString &strErrors )
  1282. {
  1283.     if( strlen(m_strMesh) == 0 )
  1284.         return S_OK;
  1285.  
  1286.     LPDIRECT3DVERTEXBUFFER9 pVB = NULL;
  1287.     void*      pVertices = NULL;
  1288.     LPD3DXMESH pTempMesh;
  1289.     WCHAR      strMeshW[MAX_PATH];
  1290.     WCHAR      strMeshPath[MAX_PATH];
  1291.     HRESULT    hr;
  1292.     LPD3DXBUFFER pbufAdjacency;
  1293.  
  1294.     // Load the mesh from the specified file
  1295.     MultiByteToWideChar( CP_ACP, 0, m_strMesh, -1, strMeshW, MAX_PATH );
  1296.     if( FAILED( hr = EE_FindMediaFileCch( strMeshPath, MAX_PATH, strMeshW ) ) )
  1297.     {
  1298.         strErrors += L"Could not find XFile ";
  1299.         strErrors += strMeshW;
  1300.         strErrors += L"\n";
  1301.         return hr;
  1302.     }
  1303.  
  1304.     hr = D3DXLoadMeshFromX( strMeshPath, D3DXMESH_MANAGED, DXUTGetD3DDevice(), 
  1305.                             &pbufAdjacency, &m_pbufMaterials, NULL, &m_dwNumMaterials, 
  1306.                             &m_pMesh );
  1307.     if( FAILED(hr) )
  1308.     {
  1309.         SAFE_RELEASE(pbufAdjacency);
  1310.         strErrors += L"Could not load XFile ";
  1311.         strErrors += strMeshW;
  1312.         strErrors += L"\n";
  1313.         return hr;
  1314.     }
  1315.  
  1316.     // Initialize the mesh directory string
  1317.     WCHAR *pwszLastBSlash = wcsrchr( strMeshPath, L'\\' );
  1318.     if( pwszLastBSlash )
  1319.         *pwszLastBSlash = L'\0';
  1320.     else
  1321.         lstrcpyW( strMeshPath, L"." );
  1322.  
  1323.     hr = m_pMesh->OptimizeInplace(D3DXMESHOPT_VERTEXCACHE, (DWORD*)pbufAdjacency->GetBufferPointer(), NULL, NULL, NULL);
  1324.     if ( FAILED(hr) )
  1325.     {
  1326.         SAFE_RELEASE(pbufAdjacency);
  1327.         return hr;
  1328.     }
  1329.  
  1330.     SAFE_RELEASE(pbufAdjacency);
  1331.  
  1332.     // Lock the vertex buffer, to generate a simple bounding sphere
  1333.     hr = m_pMesh->GetVertexBuffer( &pVB );
  1334.     if( FAILED(hr) )
  1335.         return hr;
  1336.  
  1337.     hr = pVB->Lock( 0, 0, &pVertices, 0 );
  1338.     if( FAILED(hr) )
  1339.     {
  1340.         SAFE_RELEASE( pVB );
  1341.         return hr;
  1342.     }
  1343.  
  1344.     hr = D3DXComputeBoundingSphere( (D3DXVECTOR3*)pVertices, m_pMesh->GetNumVertices(), 
  1345.                                     D3DXGetFVFVertexSize(m_pMesh->GetFVF()), &m_vObjectCenter, 
  1346.                                     &m_fObjectRadius );
  1347.     if( FAILED(hr) )
  1348.     {
  1349.         pVB->Unlock();
  1350.         SAFE_RELEASE( pVB );
  1351.         return hr;
  1352.     }
  1353.  
  1354.     // Adjust near/far clip planes of projection matrix based on the object radius
  1355.     const D3DSURFACE_DESC *pBackBufferSurfaceDesc = DXUTGetBackBufferSurfaceDesc();
  1356.     FLOAT fAspect = (FLOAT)pBackBufferSurfaceDesc->Width / (FLOAT)pBackBufferSurfaceDesc->Height;
  1357.     D3DXMatrixPerspectiveFovLH( &m_matProj, D3DX_PI/4, fAspect, 
  1358.                                 m_fObjectRadius/64.0f, m_fObjectRadius*64.0f );
  1359.     DXUTGetD3DDevice()->SetTransform( D3DTS_PROJECTION, &m_matProj );
  1360.  
  1361.     m_ArcBallMesh.SetTranslationRadius( m_fObjectRadius );
  1362.     m_ArcBallView.SetTranslationRadius( m_fObjectRadius );
  1363.  
  1364.     if( 0 == m_dwNumMaterials )
  1365.     {
  1366.         pVB->Unlock();
  1367.         SAFE_RELEASE( pVB );
  1368.         return E_INVALIDARG;
  1369.     }
  1370.  
  1371.     // Get the array of materials out of the returned buffer, allocate a
  1372.     // texture array, and load the textures
  1373.     m_pMaterials = (D3DXMATERIAL*)m_pbufMaterials->GetBufferPointer();
  1374.     m_ppTextures = new LPDIRECT3DTEXTURE9[m_dwNumMaterials];
  1375.  
  1376.     // Change the current directory to the .x's directory so
  1377.     // that the search can find the texture files.
  1378.     WCHAR wszWorkingDir[MAX_PATH];
  1379.     GetCurrentDirectory( MAX_PATH, wszWorkingDir );
  1380.     wszWorkingDir[MAX_PATH - 1] = L'\0';
  1381.     SetCurrentDirectory( strMeshPath );
  1382.  
  1383.     for( UINT i=0; i<m_dwNumMaterials; i++ )
  1384.     {
  1385.         m_ppTextures[i] = NULL;
  1386.         TCHAR strTextureName[MAX_PATH];
  1387.         TCHAR strTexturePath[MAX_PATH] = _T("");
  1388.         if( m_pMaterials[i].pTextureFilename != NULL && strlen( m_pMaterials[i].pTextureFilename ) != 0 )
  1389.         {
  1390.             MultiByteToWideChar( CP_ACP, 0, m_pMaterials[i].pTextureFilename, -1, strTextureName, MAX_PATH );
  1391.             if( FAILED( hr = EE_FindMediaFileCch( strTexturePath, MAX_PATH, strTextureName ) ) )
  1392.             {
  1393.                 strErrors += TEXT("Could not find texture ");
  1394.                 strErrors += strTextureName;
  1395.                 strErrors += TEXT(" referenced by XFile ");
  1396.                 strErrors += strMeshW;
  1397.                 strErrors += TEXT("\n");
  1398.             }
  1399.             else if( FAILED( hr = D3DXCreateTextureFromFile( DXUTGetD3DDevice(), strTexturePath, &m_ppTextures[i] ) ) )
  1400.             {
  1401.                 strErrors += TEXT("Could not load texture ");
  1402.                 strErrors += strTextureName;
  1403.                 strErrors += TEXT(" referenced by XFile ");
  1404.                 strErrors += strMeshW;
  1405.                 strErrors += TEXT("\n");
  1406.             }
  1407.         }
  1408.     }
  1409.  
  1410.     SetCurrentDirectory( wszWorkingDir );
  1411.  
  1412.     pVB->Unlock();
  1413.     SAFE_RELEASE( pVB );
  1414.  
  1415.     // Make sure there are normals, which are required for the tesselation
  1416.     // enhancement
  1417.     if( !(m_pMesh->GetFVF() & D3DFVF_NORMAL) )
  1418.     {
  1419.         hr = m_pMesh->CloneMeshFVF( m_pMesh->GetOptions(), 
  1420.                                           m_pMesh->GetFVF() | D3DFVF_NORMAL, 
  1421.                                           DXUTGetD3DDevice(), &pTempMesh );
  1422.         if( FAILED(hr) )
  1423.             return hr;
  1424.  
  1425.         D3DXComputeNormals( pTempMesh, NULL );
  1426.  
  1427.         SAFE_RELEASE( m_pMesh );
  1428.         m_pMesh = pTempMesh;
  1429.     }
  1430.  
  1431.     return S_OK;
  1432. }
  1433.  
  1434.  
  1435. void CRenderView::UnloadMesh()
  1436. {
  1437.     for( UINT i = 0; i < m_dwNumMaterials; i++ )
  1438.         SAFE_RELEASE( m_ppTextures[i] );
  1439.     SAFE_DELETE_ARRAY( m_ppTextures );
  1440.     SAFE_RELEASE( m_pMesh );
  1441.     SAFE_RELEASE( m_pbufMaterials );
  1442.     m_dwNumMaterials = 0L;
  1443.     m_strMesh[0] = 0;
  1444. }
  1445.  
  1446. LRESULT CRenderView::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  1447. {
  1448.     // If this is a mouse message, we need to map the coordinates
  1449.     // to relative to the render window.
  1450.     if( WM_LBUTTONDOWN == message ||
  1451.         WM_LBUTTONDBLCLK == message ||
  1452.         WM_LBUTTONUP == message ||
  1453.         WM_MBUTTONDOWN == message ||
  1454.         WM_MBUTTONDBLCLK == message ||
  1455.         WM_MBUTTONUP == message ||
  1456.         WM_RBUTTONDOWN == message ||
  1457.         WM_RBUTTONDBLCLK == message ||
  1458.         WM_RBUTTONUP == message ||
  1459.         WM_XBUTTONDOWN == message ||
  1460.         WM_XBUTTONDBLCLK == message ||
  1461.         WM_XBUTTONUP == message ||
  1462.         WM_MOUSEMOVE == message ||
  1463.         WM_MOUSEWHEEL == message )
  1464.     {
  1465.         POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
  1466.         // Map point to parent's coordinates.
  1467.         ::MapWindowPoints( GetSafeHwnd(), DXUTGetHWND(), &pt, 1 );
  1468.         lParam = MAKELPARAM( pt.x, pt.y );
  1469.     }
  1470.  
  1471.     if( DXUTGetShowSettingsDialog() )
  1472.     {
  1473.         // Prevent reentrant
  1474.         static bool bProcessing;
  1475.  
  1476.         if( !bProcessing )
  1477.         {
  1478.             bProcessing = true;
  1479.             DXUTStaticWndProc( DXUTGetHWND(), message, wParam, lParam );
  1480.             bProcessing = false;
  1481.         }
  1482.     }
  1483.  
  1484.     switch( message )
  1485.     {
  1486.         case WM_LBUTTONDOWN:
  1487.         {
  1488.             POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
  1489.             BOOL bSetCapture;
  1490.             m_UIElements.HandleMouseDown( pt.x, pt.y, &bSetCapture );
  1491.             if( bSetCapture )
  1492.                 SetCapture();
  1493.             break;
  1494.         }
  1495.  
  1496.         case WM_MOUSEMOVE:
  1497.         {
  1498.             POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
  1499.             m_UIElements.HandleMouseMove( pt.x, pt.y );
  1500.             break;
  1501.         }
  1502.  
  1503.         case WM_LBUTTONUP:
  1504.         {
  1505.             m_UIElements.HandleMouseUp();
  1506.             break;
  1507.         }
  1508.     }
  1509.  
  1510.     if( !m_UIElements.IsDragging() )
  1511.     {
  1512.         UINT bControl;
  1513.         bControl = GetAsyncKeyState(VK_CONTROL) & 0x8000;
  1514.  
  1515.         // Pass mouse messages to the ArcBall so it can build internal matrices
  1516.         if (!bControl)
  1517.             m_ArcBallMesh.HandleMessages( GetSafeHwnd(), message, wParam, lParam );
  1518.         else
  1519.             m_ArcBallView.HandleMessages( GetSafeHwnd(), message, wParam, lParam );
  1520.     }
  1521.  
  1522.     return CFormView::WindowProc(message, wParam, lParam);
  1523. }
  1524.  
  1525. void CRenderView::ChangeDevice() 
  1526. {
  1527.     DXUTPause( true, true );
  1528.     DXUTSetShowSettingsDialog( !DXUTGetShowSettingsDialog() );
  1529.     DXUTPause( false, false );
  1530. }
  1531.  
  1532.  
  1533. void CRenderView::SetTechnique( int iTech, CString strTechName )
  1534. {
  1535.     CString str;
  1536.     str.Format( TEXT("Rendering using technique '%s'"), strTechName );
  1537.     m_iTechnique = iTech;
  1538.     GetDlgItem(IDC_RENDERTEXT)->SetWindowText( str );
  1539.     D3DXHANDLE hTechnique = m_pEffect->GetTechnique( m_iTechnique );
  1540.     m_pEffect->SetTechnique( hTechnique );
  1541.     m_bTechniqueValidValid = FALSE;
  1542. }
  1543.  
  1544.  
  1545. void CRenderView::SetPass( int iPass, CString strPassName )
  1546. {
  1547.     m_iPass = iPass;
  1548. }
  1549.  
  1550. void CRenderView::GetPassNameList( int iTech, CStringList& passNameList )
  1551. {
  1552.     passNameList.RemoveAll();
  1553.  
  1554.     if( m_pEffect == NULL )
  1555.         return;
  1556.  
  1557.     D3DXTECHNIQUE_DESC techniqueDesc;
  1558.     D3DXHANDLE hTech;
  1559.     hTech = m_pEffect->GetTechnique( iTech );
  1560.     m_pEffect->GetTechniqueDesc( hTech, &techniqueDesc );
  1561.     for( UINT iPass = 0; iPass < techniqueDesc.Passes; iPass++ )
  1562.     {
  1563.         D3DXPASS_DESC desc;
  1564.         m_pEffect->GetPassDesc( m_pEffect->GetPass( hTech, iPass ), &desc );
  1565.         passNameList.AddTail(desc.Name);
  1566.     }
  1567. }
  1568.  
  1569.  
  1570. void CRenderView::ResetCamera()
  1571. {
  1572.     m_ArcBallMesh.Reset();
  1573.     m_ArcBallMesh.SetTranslationRadius( m_fObjectRadius );
  1574.  
  1575.     m_ArcBallView.Reset();
  1576.     m_ArcBallView.SetTranslationRadius( m_fObjectRadius );
  1577. }
  1578.  
  1579.  
  1580. BOOL FileExists( CString& strPath )
  1581. {
  1582.     HANDLE file;
  1583.  
  1584.     file = CreateFile( (LPCTSTR)strPath, GENERIC_READ, FILE_SHARE_READ, NULL, 
  1585.                        OPEN_EXISTING, 0, NULL );
  1586.     if( INVALID_HANDLE_VALUE != file )
  1587.     {
  1588.         CloseHandle( file );
  1589.         return TRUE;
  1590.     }
  1591.     return FALSE;
  1592. }
  1593.  
  1594. HRESULT CRenderView::EE_FindMediaFileCb( TCHAR* szDestPath, int cbDest, TCHAR* strFilename )
  1595. {
  1596.     return EE_FindMediaFileCch( szDestPath, cbDest / sizeof(TCHAR), strFilename );
  1597.  
  1598. }
  1599.  
  1600. // 1. Look in same dir as effects file (EffectFileDir)
  1601. // 2. Look in EffectFileDir\Media
  1602. // 3. Look in EffectFileDir\..\Media
  1603. // 4. Look in usual DxUtil_FindMediaFile paths
  1604. HRESULT CRenderView::EE_FindMediaFileCch( TCHAR* szDestPath, int cchDest, TCHAR* strFilename )
  1605. {
  1606.     CString strDoc = GetDocument()->GetPathName();
  1607.     CString strDocT;
  1608.     int iChar = strDoc.ReverseFind( TEXT('\\') );
  1609.     if( iChar >= 0 )
  1610.     {
  1611.         strDoc = strDoc.Left( iChar );
  1612.  
  1613.         strDocT = strDoc + TEXT("\\") + strFilename;
  1614.         if( FileExists( strDocT) )
  1615.         {
  1616.             _tcsncpy( szDestPath, strDocT, cchDest );
  1617.             szDestPath[cchDest-1] = 0; // _tcsncpy doesn't NULL term if it runs out of space
  1618.             return S_OK;
  1619.         }
  1620.  
  1621.         strDocT = strDoc + TEXT("\\Media\\") + strFilename;
  1622.         if( FileExists( strDocT) )
  1623.         {
  1624.             _tcsncpy( szDestPath, strDocT, cchDest );
  1625.             szDestPath[cchDest-1] = 0; // _tcsncpy doesn't NULL term if it runs out of space
  1626.             return S_OK;
  1627.         }
  1628.  
  1629.         strDocT = strDoc + TEXT("\\..\\Media\\" + strFilename);
  1630.         if( FileExists( strDocT) )
  1631.         {
  1632.             _tcsncpy( szDestPath, strDocT, cchDest );
  1633.             szDestPath[cchDest-1] = 0; // _tcsncpy doesn't NULL term if it runs out of space
  1634.             return S_OK;
  1635.         }
  1636.     }
  1637.     return DXUTFindDXSDKMediaFileCch( szDestPath, cchDest, strFilename );
  1638. }
  1639.  
  1640.